home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_enumerate.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  9.3 KB  |  275 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import unittest
  5. from test import test_support
  6.  
  7. class G:
  8.     '''Sequence using __getitem__'''
  9.     
  10.     def __init__(self, seqn):
  11.         self.seqn = seqn
  12.  
  13.     
  14.     def __getitem__(self, i):
  15.         return self.seqn[i]
  16.  
  17.  
  18.  
  19. class I:
  20.     '''Sequence using iterator protocol'''
  21.     
  22.     def __init__(self, seqn):
  23.         self.seqn = seqn
  24.         self.i = 0
  25.  
  26.     
  27.     def __iter__(self):
  28.         return self
  29.  
  30.     
  31.     def next(self):
  32.         if self.i >= len(self.seqn):
  33.             raise StopIteration
  34.         
  35.         v = self.seqn[self.i]
  36.         self.i += 1
  37.         return v
  38.  
  39.  
  40.  
  41. class Ig:
  42.     '''Sequence using iterator protocol defined with a generator'''
  43.     
  44.     def __init__(self, seqn):
  45.         self.seqn = seqn
  46.         self.i = 0
  47.  
  48.     
  49.     def __iter__(self):
  50.         for val in self.seqn:
  51.             yield val
  52.         
  53.  
  54.  
  55.  
  56. class X:
  57.     '''Missing __getitem__ and __iter__'''
  58.     
  59.     def __init__(self, seqn):
  60.         self.seqn = seqn
  61.         self.i = 0
  62.  
  63.     
  64.     def next(self):
  65.         if self.i >= len(self.seqn):
  66.             raise StopIteration
  67.         
  68.         v = self.seqn[self.i]
  69.         self.i += 1
  70.         return v
  71.  
  72.  
  73.  
  74. class E:
  75.     '''Test propagation of exceptions'''
  76.     
  77.     def __init__(self, seqn):
  78.         self.seqn = seqn
  79.         self.i = 0
  80.  
  81.     
  82.     def __iter__(self):
  83.         return self
  84.  
  85.     
  86.     def next(self):
  87.         3 // 0
  88.  
  89.  
  90.  
  91. class N:
  92.     '''Iterator missing next()'''
  93.     
  94.     def __init__(self, seqn):
  95.         self.seqn = seqn
  96.         self.i = 0
  97.  
  98.     
  99.     def __iter__(self):
  100.         return self
  101.  
  102.  
  103.  
  104. class EnumerateTestCase(unittest.TestCase):
  105.     enum = enumerate
  106.     seq = 'abc'
  107.     res = [
  108.         (0, 'a'),
  109.         (1, 'b'),
  110.         (2, 'c')]
  111.     
  112.     def test_basicfunction(self):
  113.         self.assertEqual(type(self.enum(self.seq)), self.enum)
  114.         e = self.enum(self.seq)
  115.         self.assertEqual(iter(e), e)
  116.         self.assertEqual(list(self.enum(self.seq)), self.res)
  117.         self.enum.__doc__
  118.  
  119.     
  120.     def test_getitemseqn(self):
  121.         self.assertEqual(list(self.enum(G(self.seq))), self.res)
  122.         e = self.enum(G(''))
  123.         self.assertRaises(StopIteration, e.next)
  124.  
  125.     
  126.     def test_iteratorseqn(self):
  127.         self.assertEqual(list(self.enum(I(self.seq))), self.res)
  128.         e = self.enum(I(''))
  129.         self.assertRaises(StopIteration, e.next)
  130.  
  131.     
  132.     def test_iteratorgenerator(self):
  133.         self.assertEqual(list(self.enum(Ig(self.seq))), self.res)
  134.         e = self.enum(Ig(''))
  135.         self.assertRaises(StopIteration, e.next)
  136.  
  137.     
  138.     def test_noniterable(self):
  139.         self.assertRaises(TypeError, self.enum, X(self.seq))
  140.  
  141.     
  142.     def test_illformediterable(self):
  143.         self.assertRaises(TypeError, list, self.enum(N(self.seq)))
  144.  
  145.     
  146.     def test_exception_propagation(self):
  147.         self.assertRaises(ZeroDivisionError, list, self.enum(E(self.seq)))
  148.  
  149.     
  150.     def test_argumentcheck(self):
  151.         self.assertRaises(TypeError, self.enum)
  152.         self.assertRaises(TypeError, self.enum, 1)
  153.         self.assertRaises(TypeError, self.enum, 'abc', 2)
  154.  
  155.     
  156.     def test_tuple_reuse(self):
  157.         self.assertEqual(len(set(map(id, list(enumerate(self.seq))))), len(self.seq))
  158.         self.assertEqual(len(set(map(id, enumerate(self.seq)))), min(1, len(self.seq)))
  159.  
  160.  
  161.  
  162. class MyEnum(enumerate):
  163.     pass
  164.  
  165.  
  166. class SubclassTestCase(EnumerateTestCase):
  167.     enum = MyEnum
  168.  
  169.  
  170. class TestEmpty(EnumerateTestCase):
  171.     seq = ''
  172.     res = []
  173.  
  174.  
  175. class TestBig(EnumerateTestCase):
  176.     seq = range(10, 20000, 2)
  177.     res = zip(range(20000), seq)
  178.  
  179.  
  180. class TestReversed(unittest.TestCase):
  181.     
  182.     def test_simple(self):
  183.         
  184.         class A:
  185.             
  186.             def __getitem__(self, i):
  187.                 if i < 5:
  188.                     return str(i)
  189.                 
  190.                 raise StopIteration
  191.  
  192.             
  193.             def __len__(self):
  194.                 return 5
  195.  
  196.  
  197.         for data in ('abc', range(5), tuple(enumerate('abc')), A(), xrange(1, 17, 5)):
  198.             self.assertEqual(list(data)[::-1], list(reversed(data)))
  199.         
  200.         self.assertRaises(TypeError, reversed, { })
  201.  
  202.     
  203.     def test_xrange_optimization(self):
  204.         x = xrange(1)
  205.         self.assertEqual(type(reversed(x)), type(iter(x)))
  206.  
  207.     
  208.     def test_len(self):
  209.         for s in ('hello', tuple('hello'), list('hello'), xrange(5)):
  210.             self.assertEqual(len(reversed(s)), len(s))
  211.             r = reversed(s)
  212.             list(r)
  213.             self.assertEqual(len(r), 0)
  214.         
  215.         
  216.         class SeqWithWeirdLen:
  217.             called = False
  218.             
  219.             def __len__(self):
  220.                 if not self.called:
  221.                     self.called = True
  222.                     return 10
  223.                 
  224.                 raise ZeroDivisionError
  225.  
  226.             
  227.             def __getitem__(self, index):
  228.                 return index
  229.  
  230.  
  231.         r = reversed(SeqWithWeirdLen())
  232.         self.assertRaises(ZeroDivisionError, len, r)
  233.  
  234.     
  235.     def test_gc(self):
  236.         
  237.         class Seq:
  238.             
  239.             def __len__(self):
  240.                 return 10
  241.  
  242.             
  243.             def __getitem__(self, index):
  244.                 return index
  245.  
  246.  
  247.         s = Seq()
  248.         r = reversed(s)
  249.         s.r = r
  250.  
  251.     
  252.     def test_args(self):
  253.         self.assertRaises(TypeError, reversed)
  254.         self.assertRaises(TypeError, reversed, [], 'extra')
  255.  
  256.  
  257.  
  258. def test_main(verbose = None):
  259.     testclasses = (EnumerateTestCase, SubclassTestCase, TestEmpty, TestBig, TestReversed)
  260.     test_support.run_unittest(*testclasses)
  261.     import sys
  262.     if verbose and hasattr(sys, 'gettotalrefcount'):
  263.         counts = [
  264.             None] * 5
  265.         for i in xrange(len(counts)):
  266.             test_support.run_unittest(*testclasses)
  267.             counts[i] = sys.gettotalrefcount()
  268.         
  269.         print counts
  270.     
  271.  
  272. if __name__ == '__main__':
  273.     test_main(verbose = True)
  274.  
  275.